home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 52 / Amiga Format AFCD52 (Issue 136, May 2000).iso / -serious- / workbench / directoryopus4 / dopus4_src / dopus_print / printreq.c < prev    next >
C/C++ Source or Header  |  2000-03-11  |  31KB  |  875 lines
  1. /*
  2.  
  3. Directory Opus 4
  4. Original GPL release version 4.12
  5. Copyright 1993-2000 Jonathan Potter
  6.  
  7. This program is free software; you can redistribute it and/or
  8. modify it under the terms of the GNU General Public License
  9. as published by the Free Software Foundation; either version 2
  10. of the License, or (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program; if not, write to the Free Software
  19. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20.  
  21. All users of Directory Opus 4 (including versions distributed
  22. under the GPL) are entitled to upgrade to the latest version of
  23. Directory Opus version 5 at a reduced price. Please see
  24. http://www.gpsoft.com.au for more information.
  25.  
  26. The release of Directory Opus 4 under the GPL in NO WAY affects
  27. the existing commercial status of Directory Opus 5.
  28.  
  29. */
  30.  
  31. #include "print.h"
  32.  
  33. enum {
  34.     PRINT_FILEREQUESTER,
  35.     PRINT_FILE,
  36.  
  37.     PRINT_TOPMARGIN,
  38.     PRINT_BOTTOMMARGIN,
  39.     PRINT_LEFTMARGIN,
  40.     PRINT_RIGHTMARGIN,
  41.     PRINT_TABSIZE,
  42.     PRINT_PITCH,
  43.     PRINT_QUALITY,
  44.     PRINT_EJECTPAGE,
  45.  
  46.     PRINT_HEADERFOOTER,
  47.     HEADFOOT_TITLE,
  48.     HEADFOOT_DATE,
  49.     HEADFOOT_PAGENUMBER,
  50.     HEADFOOT_TITLESTRING,
  51.     HEADFOOT_TEXTSTYLE,
  52.  
  53.     OUTPUT_PRINTER,
  54.     OUTPUT_FILE,
  55.     OUTPUT_FILEREQUESTER,
  56.     OUTPUT_FILESTRING,
  57.  
  58.     PRINT_PRINT,
  59.     PRINT_EXIT,
  60.  
  61.     PRINT_NUM_GADGETS};
  62.  
  63. struct TagItem
  64.     print_filerequester_gadget[]={
  65.         {RO_Type,OBJECT_GADGET},
  66.         {RO_GadgetType,GADGET_TINYGLASS},
  67.         {RO_GadgetID,PRINT_FILEREQUESTER},
  68.         {RO_TopFine,-5},
  69.         {RO_Left,5},
  70.         {RO_WidthFine,24},
  71.         {RO_Height,1},
  72.         {RO_HeightFine,4},
  73.         {RO_TextNum,STR_FILE},
  74.         {RO_TextPos,TEXTPOS_LEFT},
  75.         {RO_HighRecess,TRUE},
  76.         {TAG_END,0}},
  77.     print_file_gadget[]={
  78.         {RO_Type,OBJECT_GADGET},
  79.         {RO_GadgetType,GADGET_STRING},
  80.         {RO_GadgetID,PRINT_FILE},
  81.         {RO_Left,5},
  82.         {RO_LeftFine,30},
  83.         {RO_TopFine,-3},
  84.         {RO_Width,35},
  85.         {RO_WidthFine,-14},
  86.         {RO_Height,1},
  87.         {RO_StringLen,256},
  88.         {TAG_END,0}},
  89.  
  90.     print_topmargin_gadget[]={
  91.         {RO_Type,OBJECT_GADGET},
  92.         {RO_GadgetType,GADGET_INTEGER},
  93.         {RO_GadgetID,PRINT_TOPMARGIN},
  94.         {RO_Left,14},
  95.         {RO_LeftFine,1},
  96.         {RO_Top,1},
  97.         {RO_TopFine,4},
  98.         {RO_Width,3},
  99.         {RO_Height,1},
  100.         {RO_TextNum,STR_TOP_MARGIN},
  101.         {RO_TextPos,TEXTPOS_LEFT},
  102.         {RO_StringLen,4},
  103.         {TAG_END,0}},
  104.     print_bottommargin_gadget[]={
  105.         {RO_Type,OBJECT_GADGET},
  106.         {RO_GadgetType,GADGET_INTEGER},
  107.         {RO_GadgetID,PRINT_BOTTOMMARGIN},
  108.         {RO_Left,14},
  109.         {RO_LeftFine,1},
  110.         {RO_Top,2},
  111.         {RO_TopFine,11},
  112.         {RO_Width,3},
  113.         {RO_Height,1},
  114.         {RO_TextNum,STR_BOTTOM_MARGIN},
  115.         {RO_TextPos,TEXTPOS_LEFT},
  116.         {RO_StringLen,4},
  117.         {TAG_END,0}},
  118.     print_leftmargin_gadget[]={
  119.         {RO_Type,OBJECT_GADGET},
  120.         {RO_GadgetType,GADGET_INTEGER},
  121.         {RO_GadgetID,PRINT_LEFTMARGIN},
  122.         {RO_Left,14},
  123.         {RO_LeftFine,1},
  124.         {RO_Top,3},
  125.         {RO_TopFine,18},
  126.         {RO_Width,3},
  127.         {RO_Height,1},
  128.         {RO_TextNum,STR_LEFT_MARGIN},
  129.         {RO_TextPos,TEXTPOS_LEFT},
  130.         {RO_StringLen,4},
  131.         {TAG_END,0}},
  132.     print_rightmargin_gadget[]={
  133.         {RO_Type,OBJECT_GADGET},
  134.         {RO_GadgetType,GADGET_INTEGER},
  135.         {RO_GadgetID,PRINT_RIGHTMARGIN},
  136.         {RO_Left,14},
  137.         {RO_LeftFine,1},
  138.         {RO_Top,4},
  139.         {RO_TopFine,25},
  140.         {RO_Width,3},
  141.         {RO_Height,1},
  142.         {RO_TextNum,STR_RIGHT_MARGIN},
  143.         {RO_TextPos,TEXTPOS_LEFT},
  144.         {RO_StringLen,4},
  145.         {TAG_END,0}},
  146.  
  147.     print_tabsize_gadget[]={
  148.         {RO_Type,OBJECT_GADGET},
  149.         {RO_GadgetType,GADGET_INTEGER},
  150.         {RO_GadgetID,PRINT_TABSIZE},
  151.         {RO_Left,32},
  152.         {RO_Top,1},
  153.         {RO_TopFine,4},
  154.         {RO_Width,3},
  155.         {RO_Height,1},
  156.         {RO_TextNum,STR_TAB_SIZE},
  157.         {RO_TextPos,TEXTPOS_LEFT},
  158.         {RO_StringLen,3},
  159.         {TAG_END,0}},
  160.     print_pitch_gadget[]={
  161.         {RO_Type,OBJECT_GADGET},
  162.         {RO_GadgetType,GADGET_CYCLE},
  163.         {RO_GadgetID,PRINT_PITCH},
  164.         {RO_Top,2},
  165.         {RO_TopFine,8},
  166.         {RO_Left,32},
  167.         {RO_LeftFine,-4},
  168.         {RO_Width,8},
  169.         {RO_WidthFine,24},
  170.         {RO_Height,1},
  171.         {RO_HeightFine,6},
  172.         {RO_TextNum,STR_PRINT_PITCH},
  173.         {RO_TextPos,TEXTPOS_LEFT},
  174.         {RO_HighRecess,TRUE},
  175.         {TAG_END,0}},
  176.     print_quality_gadget[]={
  177.         {RO_Type,OBJECT_GADGET},
  178.         {RO_GadgetType,GADGET_CYCLE},
  179.         {RO_GadgetID,PRINT_QUALITY},
  180.         {RO_Top,3},
  181.         {RO_TopFine,15},
  182.         {RO_Left,32},
  183.         {RO_LeftFine,-4},
  184.         {RO_Width,8},
  185.         {RO_WidthFine,24},
  186.         {RO_Height,1},
  187.         {RO_HeightFine,6},
  188.         {RO_TextNum,STR_QUALITY},
  189.         {RO_TextPos,TEXTPOS_LEFT},
  190.         {RO_HighRecess,TRUE},
  191.         {TAG_END,0}},
  192.     print_ejectpage_gadget[]={
  193.         {RO_Type,OBJECT_GADGET},
  194.         {RO_GadgetType,GADGET_CHECK},
  195.         {RO_GadgetID,PRINT_EJECTPAGE},
  196.         {RO_Top,4},
  197.         {RO_TopFine,24},
  198.         {RO_Left,20},
  199.         {RO_TextNum,STR_EJECT},
  200.         {RO_TextPos,TEXTPOS_RIGHT},
  201.         {RO_BoolOn,TRUE},
  202.         {RO_ChkCenter,TRUE},
  203.         {TAG_END,0}},
  204.  
  205.     print_headerfooter_gadget[]={
  206.         {RO_Type,OBJECT_GADGET},
  207.         {RO_GadgetType,GADGET_CYCLE},
  208.         {RO_GadgetID,PRINT_HEADERFOOTER},
  209.         {RO_Top,5},
  210.         {RO_TopFine,30},
  211.         {RO_Width,8},
  212.         {RO_WidthFine,24},
  213.         {RO_Height,1},
  214.         {RO_HeightFine,6},
  215.         {RO_TextNum,STR_CONFIGURATION},
  216.         {RO_TextPos,TEXTPOS_RIGHT},
  217.         {RO_HighRecess,TRUE},
  218.         {TAG_END,0}},
  219.     headfoot_title_gadget[]={
  220.         {RO_Type,OBJECT_GADGET},
  221.         {RO_GadgetType,GADGET_CHECK},
  222.         {RO_GadgetID,HEADFOOT_TITLE},
  223.         {RO_Top,6},
  224.         {RO_TopFine,41},
  225.         {RO_LeftFine,20},
  226.         {RO_TextNum,STR_TITLE},
  227.         {RO_TextPos,TEXTPOS_RIGHT},
  228.         {RO_ChkCenter,TRUE},
  229.         {TAG_END,0}},
  230.     headfoot_date_gadget[]={
  231.         {RO_Type,OBJECT_GADGET},
  232.         {RO_GadgetType,GADGET_CHECK},
  233.         {RO_GadgetID,HEADFOOT_DATE},
  234.         {RO_Top,7},
  235.         {RO_TopFine,46},
  236.         {RO_LeftFine,20},
  237.         {RO_TextNum,STR_DATE},
  238.         {RO_TextPos,TEXTPOS_RIGHT},
  239.         {RO_ChkCenter,TRUE},
  240.         {TAG_END,0}},
  241.     headfoot_pagenumber_gadget[]={
  242.         {RO_Type,OBJECT_GADGET},
  243.         {RO_GadgetType,GADGET_CHECK},
  244.         {RO_GadgetID,HEADFOOT_PAGENUMBER},
  245.         {RO_Top,8},
  246.         {RO_TopFine,51},
  247.         {RO_LeftFine,20},
  248.         {RO_TextNum,STR_PAGE_NUMBER},
  249.         {RO_TextPos,TEXTPOS_RIGHT},
  250.         {RO_ChkCenter,TRUE},
  251.         {TAG_END,0}},
  252.     headfoot_titlestring_gadget[]={
  253.         {RO_Type,OBJECT_GADGET},
  254.         {RO_GadgetType,GADGET_STRING},
  255.         {RO_GadgetID,HEADFOOT_TITLESTRING},
  256.         {RO_Left,8},
  257.         {RO_LeftFine,49},
  258.         {RO_Top,6},
  259.         {RO_TopFine,41},
  260.         {RO_Width,32},
  261.         {RO_WidthFine,-33},
  262.         {RO_Height,1},
  263.         {RO_StringLen,40},
  264.         {TAG_END,0}},
  265.     headfoot_textstyle_gadget[]={
  266.         {RO_Type,OBJECT_GADGET},
  267.         {RO_GadgetType,GADGET_CYCLE},
  268.         {RO_GadgetID,HEADFOOT_TEXTSTYLE},
  269.         {RO_Left,31},
  270.         {RO_LeftFine,-4},
  271.         {RO_Top,8},
  272.         {RO_TopFine,50},
  273.         {RO_Width,9},
  274.         {RO_WidthFine,24},
  275.         {RO_Height,1},
  276.         {RO_HeightFine,6},
  277.         {RO_TextNum,STR_TEXT_STYLE},
  278.         {RO_TextPos,TEXTPOS_LEFT},
  279.         {RO_HighRecess,TRUE},
  280.         {TAG_END,0}},
  281.  
  282.     output_printer_gadget[]={
  283.         {RO_Type,OBJECT_GADGET},
  284.         {RO_GadgetType,GADGET_RADIO},
  285.         {RO_GadgetID,OUTPUT_PRINTER},
  286.         {RO_Top,10},
  287.         {RO_TopFine,61},
  288.         {RO_LeftFine,22},
  289.         {RO_TextNum,STR_PRINTER},
  290.         {RO_TextPos,TEXTPOS_RIGHT},
  291.         {RO_ChkCenter,TRUE},
  292.         {TAG_END,0}},
  293.     output_file_gadget[]={
  294.         {RO_Type,OBJECT_GADGET},
  295.         {RO_GadgetType,GADGET_RADIO},
  296.         {RO_GadgetID,OUTPUT_FILE},
  297.         {RO_Top,11},
  298.         {RO_TopFine,65},
  299.         {RO_LeftFine,22},
  300.         {RO_TextNum,STR_FILE},
  301.         {RO_TextPos,TEXTPOS_RIGHT},
  302.         {RO_ChkCenter,TRUE},
  303.         {TAG_END,0}},
  304.     output_filerequester_gadget[]={
  305.         {RO_Type,OBJECT_GADGET},
  306.         {RO_GadgetType,GADGET_TINYGLASS},
  307.         {RO_GadgetID,OUTPUT_FILEREQUESTER},
  308.         {RO_Left,8},
  309.         {RO_LeftFine,45},
  310.         {RO_Top,11},
  311.         {RO_TopFine,62},
  312.         {RO_WidthFine,24},
  313.         {RO_Height,1},
  314.         {RO_HeightFine,4},
  315.         {RO_HighRecess,TRUE},
  316.         {TAG_END,0}},
  317.     output_filestring_gadget[]={
  318.         {RO_Type,OBJECT_GADGET},
  319.         {RO_GadgetType,GADGET_STRING},
  320.         {RO_GadgetID,OUTPUT_FILESTRING},
  321.         {RO_Left,8},
  322.         {RO_LeftFine,75},
  323.         {RO_Top,11},
  324.         {RO_TopFine,64},
  325.         {RO_Width,32},
  326.         {RO_WidthFine,-59},
  327.         {RO_Height,1},
  328.         {RO_StringLen,256},
  329.         {TAG_END,0}},
  330.  
  331.     print_print_gadget[]={      
  332.         {RO_Type,OBJECT_GADGET},
  333.         {RO_GadgetType,GADGET_BOOLEAN},
  334.         {RO_GadgetID,PRINT_PRINT},
  335.         {RO_Top,12},
  336.         {RO_TopFine,70},
  337.         {RO_Width,12},
  338.         {RO_Height,1},
  339.         {RO_HeightFine,4},
  340.         {RO_TextNum,STR_PRINT},
  341.         {RO_TextPos,TEXTPOS_CENTER},
  342.         {RO_HighRecess,TRUE},
  343.         {TAG_END,0}},
  344.     print_exit_gadget[]={       
  345.         {RO_Type,OBJECT_GADGET},
  346.         {RO_GadgetType,GADGET_BOOLEAN},
  347.         {RO_GadgetID,PRINT_EXIT},
  348.         {RO_Left,28},
  349.         {RO_LeftFine,20},
  350.         {RO_Top,12},
  351.         {RO_TopFine,70},
  352.         {RO_Width,12},
  353.         {RO_Height,1},
  354.         {RO_HeightFine,4},
  355.         {RO_TextNum,STR_EXIT},
  356.         {RO_TextPos,TEXTPOS_CENTER},
  357.         {RO_HighRecess,TRUE},
  358.         {TAG_END,0}},
  359.  
  360.     print_output_text[]={
  361.         {RO_Type,OBJECT_TEXT},
  362.         {RO_Top,9},
  363.         {RO_TopFine,57},
  364.         {RO_LeftFine,-1},
  365.         {RO_TextNum,STR_OUTPUT_TO},
  366.         {TAG_END,0}},
  367.  
  368.     *print_gadgets[]={
  369.         print_filerequester_gadget,
  370.         print_file_gadget,
  371.         print_topmargin_gadget,
  372.         print_bottommargin_gadget,
  373.         print_leftmargin_gadget,
  374.         print_rightmargin_gadget,
  375.         print_tabsize_gadget,
  376.         print_pitch_gadget,
  377.         print_quality_gadget,
  378.         print_ejectpage_gadget,
  379.         print_headerfooter_gadget,
  380.         headfoot_title_gadget,
  381.         headfoot_date_gadget,
  382.         headfoot_pagenumber_gadget,
  383.         headfoot_titlestring_gadget,
  384.         headfoot_textstyle_gadget,
  385.         output_printer_gadget,
  386.         output_file_gadget,
  387.         output_filerequester_gadget,
  388.         output_filestring_gadget,
  389.         print_print_gadget,
  390.         print_exit_gadget,
  391.         NULL};
  392.  
  393. char
  394.     *text_pitch[3],
  395.     *text_styles[6],
  396.     *text_quality[2],
  397.     *header_footer_text[2];
  398.  
  399. void get_print_default(PrintData *printdata);
  400. void show_headerfooter_gadgets(struct Gadget **gadgets,struct Window *window,PrintData *printdata,int headerfooter);
  401. void read_headerfooter_gadgets(struct Gadget **gadgets,struct Window *window,PrintData *printdata,int headerfooter);
  402.  
  403. void do_print(vis,portname,argslist,argc,argv)
  404. struct VisInfo *vis;
  405. char *portname;
  406. struct DOpusArgsList *argslist;
  407. int argc;
  408. char *argv[];
  409. {
  410.     struct RequesterBase printreq;
  411.     struct IntuiMessage *msg;
  412.     struct Window *window;
  413.     struct Gadget **gadgets,*refgad;
  414.     struct AppWindow *appwindow=NULL;
  415.     struct MsgPort *appport=NULL;
  416.     struct AppMessage *appmsg;
  417.     ULONG class;
  418.     USHORT code,gadgetid,qual;
  419.     APTR iaddress;
  420.     struct StringExtend stringex;
  421.     PrintData *printdata;
  422.     int a,headerfooter=0,waitbits;
  423.     struct Requester busyreq;
  424.     char *print_file_buffer,
  425.         *print_topmargin_buffer,
  426.         *print_bottommargin_buffer,
  427.         *print_leftmargin_buffer,
  428.         *print_rightmargin_buffer,
  429.         *print_tabsize_buffer,
  430.         *output_filestring_buffer;
  431.  
  432.     for (a=0;a<3;a++) text_pitch[a]=string_table[STR_PICA+a];
  433.     for (a=0;a<6;a++) text_styles[a]=string_table[STR_NORMAL+a];
  434.     for (a=0;a<2;a++) {
  435.         text_quality[a]=string_table[STR_DRAFT+a];
  436.         header_footer_text[a]=string_table[STR_HEADER+a];
  437.     }
  438.  
  439.     printreq.rb_width=40;
  440.     printreq.rb_height=13;
  441.     printreq.rb_flags=0;
  442.  
  443.     fill_out_req(&printreq,vis);
  444.  
  445.     printreq.rb_privateflags=0;
  446.     printreq.rb_screenname=NULL;
  447.  
  448.     if (printreq.rb_screen && !(vis->vi_flags&VISF_BORDERS)) {
  449.         printreq.rb_flags|=RBF_STRINGS;
  450.         printreq.rb_title=NULL;
  451.         printreq.rb_widthfine=45;
  452.         printreq.rb_heightfine=86;
  453.         printreq.rb_leftoffset=13;
  454.         printreq.rb_topoffset=9;
  455.     }
  456.     else {
  457.         printreq.rb_flags|=RBF_BORDERS|RBF_CLOSEGAD|RBF_STRINGS;
  458.         printreq.rb_title=string_table[STR_PRINT];
  459.         printreq.rb_widthfine=41;
  460.         printreq.rb_heightfine=83;
  461.         printreq.rb_leftoffset=11;
  462.         printreq.rb_topoffset=7;
  463.     }
  464.  
  465.     printreq.rb_extend=&stringex;
  466.     printreq.rb_idcmpflags=0;
  467.     printreq.rb_string_table=string_table;
  468.  
  469.     for (a=0;a<2;a++) {
  470.         stringex.Pens[a]=vis->vi_stringcol[a];
  471.         stringex.ActivePens[a]=vis->vi_activestringcol[a];
  472.     }
  473.     stringex.InitialModes=0;
  474.     stringex.EditHook=NULL;
  475.     stringex.WorkBuffer=NULL;
  476.     for (a=0;a<4;a++) stringex.Reserved[a]=0;
  477.  
  478.     if (!(printdata=AllocMem(sizeof(PrintData),MEMF_CLEAR))) return;
  479.  
  480.     get_print_default(printdata);
  481.     get_print_env(printdata);
  482.  
  483.     for (a=0;a<2;a++) {
  484.         if (window=OpenRequester(&printreq)) break;
  485.         CloseRequester(&printreq);
  486.  
  487.         switch (a) {
  488.             case 0:
  489.                 printreq.rb_flags&=~RBF_BORDERS;
  490.                 printreq.rb_title=NULL;
  491.                 break;
  492.  
  493.             default:
  494.                 FreeMem(printdata,sizeof(PrintData));
  495.                 return;
  496.         }
  497.     }
  498.  
  499.     if (!(gadgets=LAllocRemember(&printreq.rb_memory,sizeof(struct Gadget *)*PRINT_NUM_GADGETS,0)) ||
  500.         !(addreqgadgets(&printreq,print_gadgets,gadgets)) ||
  501.         !(AddRequesterObject(&printreq,print_output_text))) {
  502.         CloseRequester(&printreq);
  503.         FreeMem(printdata,sizeof(PrintData));
  504.         return;
  505.     }
  506.  
  507.     RefreshRequesterObject(&printreq,NULL);
  508.  
  509.     print_file_buffer=
  510.         ((struct StringInfo *)gadgets[PRINT_FILE]->SpecialInfo)->Buffer;
  511.     print_topmargin_buffer=
  512.         ((struct StringInfo *)gadgets[PRINT_TOPMARGIN]->SpecialInfo)->Buffer;
  513.     print_bottommargin_buffer=
  514.         ((struct StringInfo *)gadgets[PRINT_BOTTOMMARGIN]->SpecialInfo)->Buffer;
  515.     print_leftmargin_buffer=
  516.         ((struct StringInfo *)gadgets[PRINT_LEFTMARGIN]->SpecialInfo)->Buffer;
  517.     print_rightmargin_buffer=
  518.         ((struct StringInfo *)gadgets[PRINT_RIGHTMARGIN]->SpecialInfo)->Buffer;
  519.     print_tabsize_buffer=
  520.         ((struct StringInfo *)gadgets[PRINT_TABSIZE]->SpecialInfo)->Buffer;
  521.     output_filestring_buffer=
  522.         ((struct StringInfo *)gadgets[OUTPUT_FILESTRING]->SpecialInfo)->Buffer;
  523.  
  524.     if (portname) {
  525.         argslist->file_data=print_file_buffer;
  526.         dopus_message(DOPUSMSG_GETNEXTFILE,(APTR)argslist,portname);
  527.     }
  528.     else if (argc>0) strcpy(print_file_buffer,argv[0]);
  529.     else print_file_buffer[0]=0;
  530.  
  531.     if (printdata->top_margin<1) printdata->top_margin=1;
  532.     lsprintf(print_topmargin_buffer,"%ld",printdata->top_margin);
  533.     lsprintf(print_bottommargin_buffer,"%ld",printdata->bottom_margin);
  534.     if (printdata->left_margin<1) printdata->left_margin=1;
  535.     lsprintf(print_leftmargin_buffer,"%ld",printdata->left_margin);
  536.     lsprintf(print_rightmargin_buffer,"%ld",printdata->right_margin);
  537.     lsprintf(print_tabsize_buffer,"%ld",printdata->tab_size);
  538.  
  539.     strcpy(output_filestring_buffer,printdata->output_file);
  540.  
  541.     DoCycleGadget(gadgets[PRINT_PITCH],window,text_pitch,printdata->print_pitch);
  542.     DoCycleGadget(gadgets[PRINT_QUALITY],window,text_quality,printdata->text_quality);
  543.  
  544.     if (printdata->print_flags&PRINTFLAG_EJECT)
  545.         gadgets[PRINT_EJECTPAGE]->Flags|=GFLG_SELECTED;
  546.     else gadgets[PRINT_EJECTPAGE]->Flags&=~GFLG_SELECTED;
  547.  
  548.     if (printdata->print_flags&PRINTFLAG_FILE) {
  549.         gadgets[OUTPUT_PRINTER]->Flags&=~GFLG_SELECTED;
  550.         gadgets[OUTPUT_FILE]->Flags|=GFLG_SELECTED;
  551.     }
  552.     else {
  553.         gadgets[OUTPUT_PRINTER]->Flags|=GFLG_SELECTED;
  554.         gadgets[OUTPUT_FILE]->Flags&=~GFLG_SELECTED;
  555.     }
  556.  
  557.     show_headerfooter_gadgets(gadgets,window,printdata,headerfooter);
  558.  
  559.     if (portname) {
  560.         OffGadget(gadgets[PRINT_FILEREQUESTER],window,NULL);
  561.         OffGadget(gadgets[PRINT_FILE],window,NULL);
  562.     }
  563.  
  564.     if (!portname && WorkbenchBase &&
  565.         (appport=LCreatePort(NULL,0)))
  566.         appwindow=AddAppWindowA(0,0,window,appport,NULL);
  567.  
  568.     FOREVER {
  569.         if (appwindow) {
  570.             while (appmsg=(struct AppMessage *)GetMsg(appport)) {
  571.                 if (appmsg->am_Type==AMTYPE_APPWINDOW) {
  572.                     if (appmsg->am_NumArgs>0 && appmsg->am_ArgList[0].wa_Lock) {
  573.                         char buf[256];
  574.  
  575.                         PathName(appmsg->am_ArgList[0].wa_Lock,buf,256);
  576.                         TackOn(buf,appmsg->am_ArgList[0].wa_Name,256);
  577.                         if (CheckExist(buf,NULL)<0) {
  578.                             strcpy(print_file_buffer,buf);
  579.                             RefreshStrGad(gadgets[PRINT_FILE],window);
  580.                         }
  581.                         else DisplayBeep(NULL);
  582.                     }
  583.                     else DisplayBeep(NULL);
  584.                 }
  585.                 ReplyMsg((struct Message *)appmsg);
  586.             }
  587.         }
  588.         while (msg=(struct IntuiMessage *)GetMsg(window->UserPort)) {
  589.             class=msg->Class; code=msg->Code; qual=msg->Qualifier;
  590.             iaddress=msg->IAddress;
  591.             ReplyMsg((struct Message *)msg);
  592.  
  593.             switch (class) {
  594.                 case IDCMP_GADGETDOWN:
  595.                     gadgetid=((struct Gadget *)iaddress)->GadgetID;
  596.  
  597.                     switch (gadgetid) {
  598.                         case OUTPUT_PRINTER:
  599.                             if (!(gadgets[OUTPUT_PRINTER]->Flags&GFLG_SELECTED)) {
  600.                                 gadgets[OUTPUT_PRINTER]->Flags|=GFLG_SELECTED;
  601.                                 RefreshGList(gadgets[OUTPUT_PRINTER],window,NULL,1);
  602.                             }
  603.                             gadgets[OUTPUT_FILE]->Flags&=~GFLG_SELECTED;
  604.                             RefreshGList(gadgets[OUTPUT_FILE],window,NULL,1);
  605.                             printdata->print_flags&=~PRINTFLAG_FILE;
  606.                             break;
  607.  
  608.                         case OUTPUT_FILE:
  609.                             if (!(gadgets[OUTPUT_FILE]->Flags&GFLG_SELECTED)) {
  610.                                 gadgets[OUTPUT_FILE]->Flags|=GFLG_SELECTED;
  611.                                 RefreshGList(gadgets[OUTPUT_FILE],window,NULL,1);
  612.                             }
  613.                             gadgets[OUTPUT_PRINTER]->Flags&=~GFLG_SELECTED;
  614.                             RefreshGList(gadgets[OUTPUT_PRINTER],window,NULL,1);
  615.                             printdata->print_flags|=PRINTFLAG_FILE;
  616.                             break;
  617.                     }
  618.                     break;
  619.  
  620.                 case IDCMP_GADGETUP:
  621.                     gadgetid=((struct Gadget *)iaddress)->GadgetID;
  622.                     refgad=NULL;
  623.  
  624.                     switch (gadgetid) {
  625.                         case PRINT_TOPMARGIN:
  626.                             if (check_print_gadget(window,gadgets[PRINT_TOPMARGIN],
  627.                                 1,atoi(print_bottommargin_buffer)-5,code))
  628.                                 refgad=(struct Gadget *)iaddress;
  629.                             printdata->top_margin=atoi(print_topmargin_buffer);
  630.                             break;
  631.                         case PRINT_BOTTOMMARGIN:
  632.                             if (check_print_gadget(window,gadgets[PRINT_BOTTOMMARGIN],
  633.                                 atoi(print_topmargin_buffer)+5,999,code))
  634.                                 refgad=(struct Gadget *)iaddress;
  635.                             printdata->bottom_margin=atoi(print_bottommargin_buffer);
  636.                             break;
  637.                         case PRINT_LEFTMARGIN:
  638.                             if (check_print_gadget(window,gadgets[PRINT_LEFTMARGIN],
  639.                                 1,atoi(print_rightmargin_buffer)-1,code))
  640.                                 refgad=(struct Gadget *)iaddress;
  641.                             printdata->left_margin=atoi(print_leftmargin_buffer);
  642.                             break;
  643.                         case PRINT_RIGHTMARGIN:
  644.                             if (check_print_gadget(window,gadgets[PRINT_RIGHTMARGIN],
  645.                                 atoi(print_leftmargin_buffer)+1,999,code))
  646.                                 refgad=(struct Gadget *)iaddress;
  647.                             printdata->right_margin=atoi(print_rightmargin_buffer);
  648.                             break;
  649.  
  650.                         case PRINT_TABSIZE:
  651.                             if (check_print_gadget(window,gadgets[PRINT_TABSIZE],
  652.                                 1,10,code))
  653.                                 ActivateStrGad(gadgets[PRINT_TOPMARGIN],window);
  654.                             printdata->tab_size=atoi(print_tabsize_buffer);
  655.                             break;
  656.  
  657.                         case PRINT_PITCH:
  658.                             if (qual&(IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT)) {
  659.                                 if ((printdata->print_pitch--)==0)
  660.                                     printdata->print_pitch=PITCH_COUNT-1;
  661.                             }
  662.                             else {
  663.                                 if ((++printdata->print_pitch)==PITCH_COUNT)
  664.                                     printdata->print_pitch=0;
  665.                             }
  666.                             DoCycleGadget(gadgets[PRINT_PITCH],window,
  667.                                 text_pitch,printdata->print_pitch);
  668.                             break;
  669.  
  670.                         case PRINT_QUALITY:
  671.                             printdata->text_quality=1-printdata->text_quality;
  672.                             DoCycleGadget(gadgets[PRINT_QUALITY],window,
  673.                                 text_quality,printdata->text_quality);
  674.                             break;
  675.  
  676.                         case PRINT_HEADERFOOTER:
  677.                             read_headerfooter_gadgets(gadgets,window,printdata,headerfooter);
  678.                             headerfooter=1-headerfooter;
  679.                             show_headerfooter_gadgets(gadgets,window,printdata,headerfooter);
  680.                             break;
  681.  
  682.                         case HEADFOOT_TEXTSTYLE:
  683.                             if (qual&(IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT)) {
  684.                                 if ((printdata->headfoot[headerfooter].text_style--)==0)
  685.                                     printdata->headfoot[headerfooter].text_style=STYLE_COUNT-1;
  686.                             }
  687.                             else {
  688.                                 if ((++printdata->headfoot[headerfooter].text_style)==STYLE_COUNT)
  689.                                     printdata->headfoot[headerfooter].text_style=0;
  690.                             }
  691.                             DoCycleGadget(gadgets[HEADFOOT_TEXTSTYLE],window,
  692.                                 text_styles,printdata->headfoot[headerfooter].text_style);
  693.                             break;
  694.  
  695.                         case HEADFOOT_TITLESTRING:
  696.                             RefreshStrGad(gadgets[HEADFOOT_TITLESTRING],window);
  697.                             break;
  698.  
  699.                         case OUTPUT_FILEREQUESTER:
  700.                             if (!(get_file_byrequest(gadgets[OUTPUT_FILESTRING],window,1)))
  701.                                 break;
  702.                         case OUTPUT_FILESTRING:
  703.                             strcpy(printdata->output_file,output_filestring_buffer);
  704.                             RefreshStrGad(gadgets[OUTPUT_FILESTRING],window);
  705.                             if (gadgets[OUTPUT_PRINTER]->Flags&GFLG_SELECTED) {
  706.                                 gadgets[OUTPUT_PRINTER]->Flags&=~GFLG_SELECTED;
  707.                                 gadgets[OUTPUT_FILE]->Flags|=GFLG_SELECTED;
  708.                                 RefreshGList(gadgets[OUTPUT_PRINTER],window,NULL,2);
  709.                                 printdata->print_flags|=PRINTFLAG_FILE;
  710.                             }
  711.                             break;
  712.  
  713.                         case PRINT_FILEREQUESTER:
  714.                             get_file_byrequest(gadgets[PRINT_FILE],window,0);
  715.                             break;
  716.  
  717.                         case PRINT_EJECTPAGE:
  718.                             if (gadgets[PRINT_EJECTPAGE]->Flags&GFLG_SELECTED)
  719.                                 printdata->print_flags|=PRINTFLAG_EJECT;
  720.                             else printdata->print_flags&=~PRINTFLAG_EJECT;
  721.                             break;
  722.  
  723.                         case PRINT_PRINT:
  724.                             read_headerfooter_gadgets(gadgets,window,printdata,headerfooter);
  725.  
  726.                             SetBusyPointer(window);
  727.                             if (appwindow) RemoveAppWindow(appwindow);
  728.  
  729.                             while (print_file_buffer[0]) {
  730.                                 InitRequester(&busyreq);
  731.                                 busyreq.Width=window->RPort->Font->tf_XSize*22;
  732.                                 busyreq.Height=window->RPort->Font->tf_YSize*7;
  733.                                 busyreq.LeftEdge=(window->Width-busyreq.Width)/2;
  734.                                 busyreq.TopEdge=(window->Height-busyreq.Height)/2;
  735.                                 busyreq.Flags=NOISYREQ;
  736.                                 busyreq.BackFill=printreq.rb_bg;
  737.  
  738.                                 if (!(printfile(&printreq,print_file_buffer,printdata,&busyreq)))
  739.                                     break;
  740.  
  741.                                 if (portname) {
  742.                                     dopus_message(DOPUSMSG_UNSELECTFILE,(APTR)argslist,portname);
  743.                                     dopus_message(DOPUSMSG_GETNEXTFILE,(APTR)argslist,portname);
  744.                                 }
  745.                                 else break;
  746.                             }
  747.  
  748.                             if (appwindow)
  749.                                 appwindow=AddAppWindowA(0,0,window,appport,NULL);
  750.  
  751.                             ClearPointer(window);
  752.                             if (portname) {
  753.                                 gadgetid=PRINT_EXIT;
  754.                                 code=0x1b;
  755.                             }
  756.                             break;
  757.  
  758.                         case PRINT_EXIT:
  759.                             code=0x1b;
  760.                             break;
  761.                     }
  762.                     if (refgad) {
  763.                         RefreshStrGad(refgad,window);
  764.                         if (code!=0x9) activate_next_gadget(refgad,window);
  765.                     }
  766.                     if (gadgetid!=PRINT_EXIT) break;
  767.  
  768.                 case IDCMP_VANILLAKEY:
  769.                     if (code!=0x1b) break;
  770.  
  771.                 case IDCMP_CLOSEWINDOW:
  772.                     if (appwindow) RemoveAppWindow(appwindow);
  773.                     if (appport) LDeletePort(appport);
  774.                     read_headerfooter_gadgets(gadgets,window,printdata,headerfooter);
  775.                     CloseRequester(&printreq);
  776.                     set_print_env(printdata);
  777.                     FreeMem(printdata,sizeof(PrintData));
  778.                     return;
  779.             }
  780.         }
  781.         waitbits=1<<window->UserPort->mp_SigBit;
  782.         if (appwindow) waitbits|=1<<appport->mp_SigBit;
  783.         Wait(waitbits);
  784.     }
  785. }
  786.  
  787. void get_print_default(printdata)
  788. PrintData *printdata;
  789. {
  790.     struct Preferences prefs;
  791.  
  792.     GetPrefs(&prefs,sizeof(struct Preferences));
  793.  
  794.     printdata->top_margin=1;
  795.     printdata->bottom_margin=prefs.PaperLength;
  796.     printdata->left_margin=prefs.PrintLeftMargin;
  797.     printdata->right_margin=prefs.PrintRightMargin;
  798.  
  799.     printdata->tab_size=8;
  800.     switch (prefs.PrintPitch) {
  801.         case ELITE:
  802.             printdata->print_pitch=PITCH_ELITE;
  803.             break;
  804.         case FINE:
  805.             printdata->print_pitch=PITCH_FINE;
  806.             break;
  807.     }
  808.  
  809.     printdata->print_flags=PRINTFLAG_EJECT;
  810. }
  811.  
  812. void show_headerfooter_gadgets(gadgets,window,printdata,headerfooter)
  813. struct Gadget **gadgets;
  814. struct Window *window;
  815. PrintData *printdata;
  816. int headerfooter;
  817. {
  818.     DoCycleGadget(gadgets[PRINT_HEADERFOOTER],window,header_footer_text,
  819.         headerfooter);
  820.     DoCycleGadget(gadgets[HEADFOOT_TEXTSTYLE],window,text_styles,
  821.         printdata->headfoot[headerfooter].text_style);
  822.     strcpy(((struct StringInfo *)gadgets[HEADFOOT_TITLESTRING]->SpecialInfo)->Buffer,
  823.         printdata->headfoot[headerfooter].headfoot_title);
  824.  
  825.     if (printdata->headfoot[headerfooter].headfoot_flags&HEADFOOTFLAG_TITLE)
  826.         gadgets[HEADFOOT_TITLE]->Flags|=GFLG_SELECTED;
  827.     else gadgets[HEADFOOT_TITLE]->Flags&=~GFLG_SELECTED;
  828.  
  829.     if (printdata->headfoot[headerfooter].headfoot_flags&HEADFOOTFLAG_DATE)
  830.         gadgets[HEADFOOT_DATE]->Flags|=GFLG_SELECTED;
  831.     else gadgets[HEADFOOT_DATE]->Flags&=~GFLG_SELECTED;
  832.  
  833.     if (printdata->headfoot[headerfooter].headfoot_flags&HEADFOOTFLAG_PAGE)
  834.         gadgets[HEADFOOT_PAGENUMBER]->Flags|=GFLG_SELECTED;
  835.     else gadgets[HEADFOOT_PAGENUMBER]->Flags&=~GFLG_SELECTED;
  836.  
  837.     RefreshGList(gadgets[0],window,NULL,-1);
  838. }
  839.  
  840. void read_headerfooter_gadgets(gadgets,window,printdata,headerfooter)
  841. struct Gadget **gadgets;
  842. struct Window *window;
  843. PrintData *printdata;
  844. int headerfooter;
  845. {
  846.     strcpy(printdata->headfoot[headerfooter].headfoot_title,
  847.         ((struct StringInfo *)gadgets[HEADFOOT_TITLESTRING]->SpecialInfo)->Buffer);
  848.  
  849.     if (gadgets[HEADFOOT_TITLE]->Flags&GFLG_SELECTED)
  850.         printdata->headfoot[headerfooter].headfoot_flags|=HEADFOOTFLAG_TITLE;
  851.     else printdata->headfoot[headerfooter].headfoot_flags&=~HEADFOOTFLAG_TITLE;
  852.  
  853.     if (gadgets[HEADFOOT_DATE]->Flags&GFLG_SELECTED)
  854.         printdata->headfoot[headerfooter].headfoot_flags|=HEADFOOTFLAG_DATE;
  855.     else printdata->headfoot[headerfooter].headfoot_flags&=~HEADFOOTFLAG_DATE;
  856.  
  857.     if (gadgets[HEADFOOT_PAGENUMBER]->Flags&GFLG_SELECTED)
  858.         printdata->headfoot[headerfooter].headfoot_flags|=HEADFOOTFLAG_PAGE;
  859.     else printdata->headfoot[headerfooter].headfoot_flags&=~HEADFOOTFLAG_PAGE;
  860. }
  861.  
  862. check_print_gadget(window,gad,min,max,code)
  863. struct Window *window;
  864. struct Gadget *gad;
  865. int min,max;
  866. USHORT code;
  867. {
  868.     if (CheckNumGad(gad,window,min,max)) {
  869.         DisplayBeep(NULL);
  870.         if (code!=0x9) ActivateStrGad(gad,window);
  871.         return(0);
  872.     }
  873.     return(1);
  874. }
  875.